IRIX Base Documentation 2001 May

home *** CD-ROM | disk | FTP | other *** search

/ IRIX Base Documentation 2001 May / SGI IRIX Base Documentation 2001 May.iso / usr / share / catman / p_man / cat5 / opt.z / opt

Wrap

Text File | 1998-10-30 | 27.5 KB | 473 lines

OPT(5) Last changed: 3-10-98 NNAAMMEE OPT - Miscellaneous compiler optimizations option group SSYYNNOOPPSSIISS --OOPPTT:: ... IIMMPPLLEEMMEENNTTAATTIIOONN IRIX systems DDEESSCCRRIIPPTTIIOONN This man page describes the general optimization options accepted by the ff9900(1), ff7777(1), CCCC(1), cccc(1), and cc8899(1) commands. The --OOPPTT:: option group controls miscellaneous optimizations. This option overrides default optimizations. You can specify more than one suboption to the --OOPPTT:: option either by using colons to separate each suboption or by specifying multiple options on the command line. For example, the following command lines are equivalent: f90 -OPT:cis=ON:cray_ivdep=OFF b.f f90 -OPT:cis=ON -OPT:cray_ivdep=OFF b.f Some --OOPPTT:: suboptions are specified with a setting that either enables or disables the feature. To enable a feature, specify the suboption either alone or with ==11, ==OONN, or ==TTRRUUEE. To disable a feature, specify the suboption with either ==00, ==OOFFFF, or ==FFAALLSSEE. For example, the following command lines are equivalent: f90 -OPT:cis:cray_ivdep=OFF:div_split=FALSE a.f f90 -OPT:cis=1:cray_ivdep=0:div_split=OFF a.f For brevity, this man page shows only the OONN or OOFFFF settings to suboptions, but 00, 11, TTRRUUEE, and FFAALLSSEE are also allowed as settings. There are other options to the compiler commands that control optimization. For information on the general optimization levels, see the --OO option on the command man page for your compiler. For information about inlining and interprocedural optimization, see the --IINNLLIINNEE:: ... option or the iippaa(5) man page. For information on loop nest optimization, see the llnnoo(5) man page. The --OOPPTT:: option accepts the following suboptions: SSuubbooppttiioonnss AAccttiioonn aalliiaass==_n_a_m_e Specifies the pointer aliasing model to be used. By specifiying one of the following for _n_a_m_e, the compiler is able to make assumptions throughout the compilation: _n_a_m_e AAssssuummppttiioonn AANNYY or CCOOMMMMOONN__SSCCAALLAARR AANNYY specifies that any two memory references can be aliased unless the compiler can determine otherwise. Default pointer aliasing model. CCOOMMMMOONN__SSCCAALLAARR specifies that scalar variables that are defined in a common block along with array variables are not referenced or modified by any accesses of the array variables. (C and C++ only) ccrraayy__ppooiinntteerr or nnoo__ccrraayy__ppooiinntteerr ccrraayy__ppooiinntteerr asserts that a pointee's storage is never overlaid on another variable's storage. The pointee is stored in memory before a call to an external procedure and is read out of memory as its next reference. It is also stored before a RREETTUURRNN or EENNDD statement of a subprogram nnoo__ccrraayy__ppooiinntteerr asserts that a pointee's storage can overlay on another variable's storage. Default. (Fortran 90 or FORTRAN 77) TTYYPPEEDD or NNOO__TTYYPPEEDD TTYYPPEEDD specifies that pointers of distinct base types are assumed to point to distinct, non-overlapping objects. NNOO__TTYYPPEEDD specifies that pointers to different base types may point to the same object. (C and C++ only) UUNNNNAAMMEEDD or NNOO__UUNNNNAAMMEEDD UUNNNNAAMMEEDD specifies that pointers are assumed never to point to named objects. NNOO__UUNNNNAAMMEEDD specifies that the pointer may point to named object. (C and C++ only) RREESSTTRRIICCTT or NNOO__RREESSTTRRIICCTT RREESSTTRRIICCTT specifies that distinct pointers are assumed to point to distinct, non-overlapping objects. NNOO__RREESSTTRRIICCTT specifies that distinct pointers may point to overlapping storage. (C and C++ only) ppaarrmm or nnoo__ppaarrmm ppaarrmm asserts that Fortran parameters do not alias to any other variable. Default. nnoo__ppaarrmm asserts that Fortran parameters can alias to any other variable. (Fortran 90 or FORTRAN 77) cciiss[[ == (( OONN||OOFFFF ))]] Converts SIN/COS pairs with the same argument to a single call that calculates both values at once. The default is OONN. ccoonnsstt__ccooppyy__lliimmiitt==_n (cccc, cc8899, and ff7777 only) Do not do const/copy propagation if there are more than _n expressions in a subprogram. Default is _n=10000. ccrraayy__iivvddeepp[[ == (( OONN||OOFFFF ))]] Specifies that the compiler should use UNICOS semantics when a !!DDIIRR$$ IIVVDDEEPP directive (Fortran) or a ##pprraaggmmaa iivvddeepp statement (C) is encountered. With UNICOS semantics, the compiler ignores all loop iteration dependencies. The default is OOFFFF. Also see the --OOPPTT::lliibbeerraall__iivvddeepp[[ == (( OONN||OOFFFF ))]] option. ddiivv__sspplliitt[[ == (( OONN||OOFFFF ))]] Enables or disables the calculation of x/y as x*(1.0/y). The default is ddiivv__sspplliitt==OOFFFF. This is typically enabled by the --OOPPTT::IIEEEEEE__aarriitthhmmeettiicc==33 option. Also see the --OOPPTT::rreecciipp option. This option should be used with caution because it produces less accurate results. ffaasstt__bbiitt__iinnttrriinnssiiccss[[ == (( OONN||OOFFFF ))]] OONN turns off the check for the bit count being within range for Fortran bit intrinsics (for example, BBTTEESSTT and IISSHHFFTT). The default is OOFFFF. ffaasstt__ccoommpplleexx[[ == (( OONN||OOFFFF ))]] ffaasstt__ccoommpplleexx==OONN enables fast calculations for values declared as type complex. When set to OONN, complex absolute value (norm) and complex division use fast algorithms that overflow for an operand (divisor, in the case of division) that has an absolute value that is larger than the square root of the largest representable floating-point number (or underflow for a value that is smaller than the square root of the smallest representable floating point number). The default is OOFFFF. ffaasstt__ccoommpplleexx==OONN is enabled if --OOPPTT::rroouunnddooffff==33 is in effect. ffaasstt__eexxpp[[ == (( OONN||OOFFFF ))]] ffaasstt__eexxpp==OONN enables optimization of exponentiation by replacing the run-time call for exponentiation by multiplication and/or square root operations for certain compile-time constant exponents (integers and halves). This can produce differently rounded results than the run-time function. ffaasstt__eexxpp==OONN is in effect unless --OOPPTT::rroouunnddooffff==11 is in effect. The default is OONN. ffaasstt__iioo[[ == (( OONN||OOFFFF ))]] (C/C++ only) Enables inlining of pprriinnttff(()), ffpprriinnttff(()), sspprriinnttff(()), ssccaannff(()), ffssccaannff(()), ssssccaannff(()), and pprriinnttww(()). This option is in effect only when the candidates for inlining are marked as intrinsic in the ssttddiioo..hh and ccuurrsseess..hh files. The default is OOFFFF. ffaasstt__nniinntt[[ == (( OONN||OOFFFF ))]] ffaasstt__nniinntt==OONN uses hardware features to implement NNIINNTT and AANNIINNTT (both single- and double-precision versions). The default is OOFFFF, but ffaasstt__nniinntt==OONN is enabled by default if --OOPPTT::rroouunnddooffff==33 is in effect. ffaasstt__nniinntt==OONN is also enabled when ffaasstt__ttrruunncc==OONN is in effect. FORTRAN 77 and Fortran 90 only: This violates the FORTRAN 77 and Fortran 90 standards for certain argument values because it rounds as specified by the IEEE standard, rather than as specified by the Fortran standards (for example, FORTRAN 77 specifies that NNIINNTT((11..55)) is 2, and NNIINNTT((22..55)) is 3, while IEEE rounds both of these to 2). If ffaasstt__ttrruunncc is also enabled, NNIINNTT and AANNIINNTT are implemented with round instructions (i.e., ffaasstt__nniinntt takes precedence for these intrinsics). ffaasstt__ssqqrrtt[[ == (( OONN||OOFFFF ))]] ffaasstt__ssqqrrtt==OONN calculates square roots using the identity ssqqrrtt((xx)) == xx**rrssqqrrtt((xx)), where rrssqqrrtt is the reciprocal square root operation. The default is OOFFFF. This option is ignored unless --mmiippss44 and --rr88000000 are also in effect. WARNING: This option results in ssqqrrtt((00..00)) producing a NaN result. Use it only when zero ssqqrrtt operands are not valid. ffaasstt__ttrruunncc[[ == (( OONN||OOFFFF ))]] ffaasstt__ttrruunncc==OONN inlines the NNIINNTT, AANNIINNTT, AAIINNTT, and AAMMOODD Fortran intrinsics, both single- and double-precision versions. The default is OOFFFF. ffaasstt__ttrruunncc==OONN is enabled automatically if --OOPPTT::rroouunnddooffff==11 (or greater) is in effect. FORTRAN 77 and Fortran 90 only: Although this is compliant with the FORTRAN 77 and Fortran 90 standards, it reduces the valid argument range. If ffaasstt__nniinntt is also enabled, NNIINNTT and AANNIINNTT are implemented with round instructions (that is, ffaasstt__nniinntt takes precedence for these intrinsics). ffoolldd__rreeaassssoocciiaattee[[ == (( OONN||OOFFFF ))]] ffoolldd__rreeaassssoocciiaattee==OONN allows optimizations involving reassociation of floating-point quantities. The default is OOFFFF. ffoolldd__rreeaassssoocciiaattee==OONN is enabled automatically when --OO33 is in effect or when --OOPPTT::rroouunnddooffff==22 or greater is in effect. ffoolldd__uunnssaaffee__rreellooppss[[ == (( OONN||OOFFFF ))]] ffoolldd__uunnssaaffee__rreellooppss==OONN folds relational operators in the presence of possible integer overflow. The default is OONN. ffoolldd__uunnssiiggnneedd__rreellooppss[[ == (( OONN||OOFFFF ))]] ffoolldd__uunnssiiggnneedd__rreellooppss==OONN folds unsigned relational operators in the presence of possible integer overflow. The default is OOFFFF. ggoott__ccaallll__ccoonnvveerrssiioonn[[ == (( OONN||OOFFFF ))]] ggoott__ccaallll__ccoonnvveerrssiioonn==OONN loads function addresses to be moved out of loops. The load is set up with the proper relocation so that the address is resolved at program start-up time. The default is OOFFFF when --OO22 or lower is in effect. ggoott__ccaallll__ccoonnvveerrssiioonn==OONN when --OO33 is in effect. NOTE: This option should be disabled when compiling shared objects that contain function addresses that may be preempted by rrlldd(1). For more information, see the ddssoo(5) man page. IIEEEEEE__aarriitthhmmeettiicc==_n Specifies the level of conformance to ANSI/IEEE 754-1985, the IEEE Standard for Binary Floating-point Arithmetic, which describes a standard for, among other things, NaN and inf operands, arithmetic round off, and overflow. _n can be one of the following: _n DDeessccrriippttiioonn 1 Inhibits optimizations that produce less accurate results than required by ANSI/IEEE 754-1985. This is the default. 2 Allows compiler optimizations that can produce less accurate inexact results (but accurate exact results) on the target hardware. That is, expressions that would have produced a NaN or an inf may produce different answers, but otherwise answers are the same as those obtained when IIEEEEEE__aarriitthhmmeettiicc==11 is in effect. Examples: 00**XX may be changed to 0, and XX//XX may be changed to 1 even though this is inaccurate when XX is +inf, -inf, or NaN. 3 Performs arbitrary, mathematically valid transformations, even if they can produce inaccurate results for operations specified in ANSI/IEEE 754-1985. These transformations can cause overflow or underflow for a valid operand range. An example is the conversion of _x//_y to _x**rreecciipp((_y)) for MIPS IV targets. Also see the --OOPPTT::rroouunnddooffff==_n option. IIEEEEEE__ccoommppaarriissoonnss[[ == (( OONN||OOFFFF ))]] Forces all comparisons to yield results that conform to ANSI/IEEE 754-1985, the IEEE Standard for Binary Floating- point Arithmetic, which describes a standard for NaN and inf operands. The default is IIEEEEEE__ccoommppaarriissoonnss==OOFFFF. IIEEEEEE__ccoommppaarriissoonnss==OOFFFF produces non-IEEE results for comparisons. For example, xx==xx is treated as TTRRUUEE without executing a test. NOTE: This option has been deprecated and will be removed in a future release. The preferred alternative is the --OOPPTT::IIEEEEEE__NNaaNN__iinnff== option. (Fortran 90 only) IIEEEEEE__NNaaNN__iinnff[[ == (( OONN||OOFFFF ))]] IIEEEEEE__NNaaNN__iinnff==OONN forces all operations that might have IEEE-754 NaN or infinity operands to yield results that conform to ANSI/IEEE 754-1985, the IEEE Standard for Binary Floating- point Arithmetic, which specifies the standard for NaN and inf operands. The default is OOFFFF. IIEEEEEE__NNaaNN__iinnff==OOFFFF produces non-IEEE results for various operations. For example, xx==xx is treated as TRUE without executing a test and xx//xx is simplified to 1 without dividing. Turning this option on may suppress many such common optimizations and hurt performance. iinnlliinnee__iinnttrriinnssiiccss[[ == (( OONN||OOFFFF ))]] iinnlliinnee__iinnttrriinnssiiccss==OOFFFF turns all Fortran intrinsics that have a library function into a call to that function. The default is OONN. lliibbeerraall__iivvddeepp[[ == (( OONN||OOFFFF ))]] Instructs the compiler to ignore all vector dependencies when encountering IIVVDDEEPP directives. The default is OOFFFF. OOlliimmiitt==_n Specifies that any routine bigger than _n should not be optimized. If --OO22 or greater is in effect and a routine is so big that the compile speed may be slow, the compiler generates a message indicating the OOlliimmiitt value that is needed to optimize. You can recompile with that value of _n, or you can recompile with --OOPPTT::OOlliimmiitt==00 and avoid having any OOlliimmiitt cutoff. ppaadd__ccoommmmoonn[[ == (( OONN||OOFFFF ))]] ppaadd__ccoommmmoonn==OONN reorganizes common blocks to improve the cache behavior of accesses to members of the common block. This may involve adding padding between members and/or breaking a common block into a collection of common blocks. The default is OOFFFF. This option should not be used unless the common block definitions (including EEQQUUIIVVAALLEENNCCEE) are consistent among all sources comprising a program. In addition, ppaadd__ccoommmmoonn==OONN should not be specified if common blocks are initialized with DDAATTAA statements. If specified, ppaadd__ccoommmmoonn==OONN must be used for all of source files in the program. ppaadd__ccoommmmoonn==OONN is supported for Fortran only. It should not be used if a common block is referenced from C code. rreecciipp[[ == (( OONN||OOFFFF ))]] rreecciipp==OONN specifies that faster, but potentially less accurate, reciprocal operations should be performed. The default is OOFFFF. If --OO33 or --OOPPTT::IIEEEEEE__aarriitthhmmeettiicc==22 or above are in effect, rreecciipp==OONN is enabled. The rreecciipp==OONN setting is effective only if --rr88000000 is in effect. rreeoorrgg__ccoommmmoonn[[ == (( OONN||OOFFFF ))]] rreeoorrgg__ccoommmmoonn==OONN reorganizes common blocks to improve the cache behavior of accesses to members of the common block. The reorganization is done only if the compiler detects that it is safe to do so. rreeoorrgg__ccoommmmoonn==OONN is enabled when --OO33 is in effect and when all files that reference the common block are compiled at --OO33.. rreeoorrgg__ccoommmmoonn==OOFFFF is set when the file that contains the common block is compiled at --OO22 (or below). rroouunnddooffff==_n Specifies the level of acceptable departure from source language floating-point, round-off, and overflow semantics. _n can be one of the following: _n DDeessccrriippttiioonn 0 Inhibits optimizations that might affect the floating-point behavior. This is the default when optimization levels --OO00, --OO11, and --OO22 are in effect. 1 Allows simple transformations that might cause limited round-off or overflow differences. Compounding such transformations could have more extensive effects. 2 Allows more extensive transformations, such as the reordering of reduction loops. This is the default level when --OO33 is in effect. 3 Enables any mathematically valid transformation. To obtain best performance in conjunction with software pipelining, specify rroouunnddooffff==22 or rroouunnddooffff==33. This is because reassociation is required for many transformations to break recurrences in loops. Also see the descriptions for the --OOPPTT::IIEEEEEE__aarriitthhmmeettiicc, --OOPPTT::ffaasstt__ccoommpplleexx, --OOPPTT::ffaasstt__ttrruunncc, and --OOPPTT::ffaasstt__nniinntt options. rrssqqrrtt[[ == (( OONN||OOFFFF ))]] rrssqqrrtt==OONN specifies that faster, but potentially less accurate, square root operations should be performed. The default is OOFFFF. If --OOPPTT::IIEEEEEE__aarriitthhmmeettiicc==22 (or above) or --OO33 are in effect, rrssqqrrtt==OONN is enabled. ssppaaccee[[ == (( OONN||OOFFFF ))]] ssppaaccee==OONN specifies that code space is to be given priority in tradeoffs with execution time in optimization choices. For instance, this forces all exits from a function to go through a single exit block. The default is OOFFFF. sswwpp[[ == (( OONN||OOFFFF ))]] sswwpp==OONN enables software pipelining. sswwpp==OONN is enabled when --OO33 is in effect. The default is OOFFFF. uunnrroollll__aannaallyyssiiss[[ == (( OONN||OOFFFF ))]] uunnrroollll__aannaallyyssiiss==OONN analyzes resource usage and recurrences in bodies of innermost loops that do not qualify for being fully unrolled. Such loops are unrolled only to the extent to which there is a potential benefit in doing so. A loop could be unrolled, for example, to decrease the shortest possible schedule length per iteration. The default is OONN. uunnrroollll__aannaallyyssiiss==OOFFFF can have the negative effect of unrolling loops less than the upper limit dictated by the OOPPTT::uunnrroollll__ttiimmeess__mmaaxx and OOPPTT::uunnrroollll__ssiizzee specifications. uunnrroollll__ssiizzee==_n Specifies the maximum size (in instructions) of an unrolled loop. Specify an integer for _n. The default is 332200. This option indirectly determines which loops can be fully unrolled. Also see the --OOPPTT::uunnrroollll__ttiimmeess__mmaaxx option. uunnrroollll__ttiimmeess__mmaaxx==_n Specifies the maximum number of times a loop will be unrolled if it is not going to be fully unrolled. Specify an integer for _n. The default is 88 when --mmiippss44 is in effect. The default is 44 when --mmiippss33 is in effect. Also see the --OOPPTT::uunnrroollll__ssiizzee option. wwrraapp__aarroouunndd__uunnssaaffee__oopptt[[ == (( OONN||OOFFFF ))]] wwrraapp__aarroouunndd__uunnssaaffee__oopptt==OOFFFF disables both the induction variable replacement and linear function test replacement optimizations. By default, these optimizations are enabled at --OO22 and --OO33. This option is disabled by default at --OO00. Setting this option to OOFFFF can degrade performance. It is provided, however, as a diagnostic tool to identify the situation described previously. SSEEEE AALLSSOO cccc(1), CCCC(1), ccoorrdd(1), ddssoo(1), ff7777(1), ff9900(1), ffppmmooddee(1), hhiinnvv(1), lldd(1), mmaakkee(1), ppiixxiiee(1), ppmmaakkee(1), pprrooff(1), rrlldd(1), ssmmaakkee(1). mmaatthh(3M). aauuttoo__pp(5), ggpp__oovveerrffllooww(5), iippaa(5), llnnoo(5), ppee__eennvviirroonn(5). _C _L_a_n_g_u_a_g_e _R_e_f_e_r_e_n_c_e _M_a_n_u_a_l, publication 007-0701-120 _M_I_P_S_p_r_o _C _a_n_d _C++ _P_r_a_g_m_a_s, publication 007-3587-001 _C_o_m_p_i_l_e_r _I_n_f_o_r_m_a_t_i_o_n _F_i_l_e (_C_I_F) _R_e_f_e_r_e_n_c_e _M_a_n_u_a_l, publication SR-2401 _M_I_P_S_P_r_o _7 _F_o_r_t_r_a_n _9_0 _C_o_m_m_a_n_d_s _a_n_d _D_i_r_e_c_t_i_v_e_s _R_e_f_e_r_e_n_c_e _M_a_n_u_a_l, publication SR-3907 This man page is available only online.